package com.chao.yyks.modular.problem.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.chao.common.util.ListUtile;
import com.chao.common.util.RequestUtile;
import com.chao.common.util.StrUtile;
import com.chao.common.util.exception.SysException;
import com.chao.yyks.modular.problem.bean.EnProblem;
import com.chao.yyks.modular.problem.bean.EnProblemAnswer;
import com.chao.yyks.modular.problem.bean.EnProblemOption;
import com.chao.yyks.modular.problem.mapper.EnProblemAnswerMapper;
import com.chao.yyks.modular.problem.mapper.EnProblemMapper;
import com.chao.yyks.modular.problem.mapper.EnProblemOptionMapper;
import com.chao.yyks.modular.problem.service.EnProblemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.chao.common.util.reaction.PageList;

import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;


/**
 * 题库ServiceImpl
 * chao
 * 2024-09-12
 */
@Service
public class EnProblemServiceImpl implements EnProblemService {

	/**
	 * 题库Mapper
	 */
	@Autowired
	private EnProblemMapper enProblemMapper;

	/**
	 * 问题答案Mapper
	 */
	@Autowired
	private EnProblemOptionMapper enProblemOptionMapper;

	/**
	 * 问题答案Mapper
	 */
	@Autowired
	private EnProblemAnswerMapper enProblemAnswerMapper;

	/**
	 * 新增题库
	 */
	@Override
	@Transactional
	public void insertEnProblem(EnProblem enProblem){
		String problemAnswer = enProblem.getProblemAnswer();

		enProblem.setProblemId(StrUtile.getId());
		enProblem.setCtime(new Date());
		enProblem.setProblemAnswer(null);
		enProblem.setCreateUserId(RequestUtile.getLoginUserId());
		enProblemMapper.insertEnProblem(enProblem);

		if(!StrUtile.isEmpty(problemAnswer) && !"1".contains(enProblem.getProblemUpType())){
			EnProblemAnswer answer = new EnProblemAnswer();
			answer.setProblemId(enProblem.getProblemId());
			answer.setProblemAnswerLong(problemAnswer);
			enProblemAnswerMapper.insertEnProblemAnswer(answer);
		}

		if(!ListUtile.isEmpty(enProblem.getOptionList())){
			for (EnProblemOption option : enProblem.getOptionList()){
				option.setOptionId(StrUtile.getId());
				option.setProblemId(enProblem.getProblemId());
			}
			enProblemOptionMapper.insertAllEnProblemOption(enProblem.getOptionList());
		}
	}

	/**
	 * 修改题库
	 */
	@Override
	@Transactional
	public void updateEnProblem(EnProblem enProblem){
		EnProblem enProblemPojo = enProblemMapper.selectEnProblemByProblemId(enProblem.getProblemId());
		if(null == enProblemPojo){
		    throw new SysException("修改题库失败:记录不存在!");
		}
		String problemAnswer = enProblem.getProblemAnswer();
		enProblemMapper.updateEnProblem(enProblem);

		if(!StrUtile.isEmpty(problemAnswer) && !"1".equals(enProblemPojo.getProblemUpType())){
			EnProblemAnswer answer = new EnProblemAnswer();
			answer.setProblemId(enProblem.getProblemId());
			answer.setProblemAnswerLong(problemAnswer);
			int i = enProblemAnswerMapper.updateEnProblemAnswer(answer);
			if(i == 0){
				enProblemAnswerMapper.insertEnProblemAnswer(answer);
			}
		}
		enProblemOptionMapper.deleteDataEnProblemOption(enProblem.getProblemId());
		if(!ListUtile.isEmpty(enProblem.getOptionList())){
			for (EnProblemOption option : enProblem.getOptionList()){
				option.setOptionId(StrUtile.getId());
				option.setProblemId(enProblem.getProblemId());
			}
			enProblemOptionMapper.insertAllEnProblemOption(enProblem.getOptionList());
		}
	}

	/**
	 * 删除题库
	 */
	@Override
	@Transactional
	public void deleteEnProblem(String problemId){
		EnProblem enProblem = enProblemMapper.selectEnProblemByProblemId(problemId);
		if(null == enProblem){
		    throw new SysException("删除题库失败:记录不存在!");
		}
		enProblemMapper.deleteEnProblem(problemId);
	}

	/**
	 * 查询题库详情
	 */
	@Override
	public EnProblem selectEnProblemByProblemId(String problemId){
		PageList<EnProblem> list = enProblemMapper.selectEnProblemByList(JSONObject.parseObject("{\"problemId\":\""+problemId+"\"}"));
		if(ListUtile.isPageEmpty(list)){
			throw new SysException("记录不存在!");
		}
		return list.getList().get(0);
	}

	/**
	 * 查询题库列表
	 */
	@Override
	public PageList<EnProblem> selectEnProblemByList(JSONObject json){
		return enProblemMapper.selectEnProblemByList(json);
	}

	/**
	 * 分页查询题库列表
	 */
	@Override
	public PageList<EnProblem> selectEnProblemByPage(JSONObject json){
		return enProblemMapper.selectEnProblemByList(StrUtile.getPageJson(json));
	}

	/**
	 * 分页查询题库列表
	 */
	@Override
	public PageList<JSONObject> selectEnProblemCHList(JSONObject json){
		json.put("studentId",RequestUtile.getLoginUserId());
		return enProblemMapper.selectEnProblemCHList(json);
	}

	/**
	 * 分页查询题库列表
	 */
	@Override
	public JSONObject selectEnProblemCH(JSONObject json){
		json.put("num",json.getIntValue("size"));
		json.put("studentId",RequestUtile.getLoginUserId());
		JSONObject data = new JSONObject();
		List<EnProblem> list = enProblemMapper.selectEnProblemCH(json);
		List<String> problemTitleList = list.stream().map(EnProblem::getProblemTitle).collect(Collectors.toList());
		List<String> problemAnswerList = list.stream().map(EnProblem::getProblemAnswer).collect(Collectors.toList());
		Collections.shuffle(problemTitleList);
		Collections.shuffle(problemAnswerList);
		data.put("problemTitleList",problemTitleList);
		data.put("problemAnswerList",problemAnswerList);
		data.put("problemList",list);
		return data;
	}

}